<?php

namespace Ignus\View;

use Ignus\View\Error\Runtime;

abstract class Template implements TemplateInterface
{
    protected static $cache = array();

    protected $parents;
    protected $env;
    protected $blocks;
    protected $traits;

    public function __construct(Environment $env)
    {
        $this->env = $env;
        $this->blocks = array();
        $this->traits = array();
    }

    /**
     * @return string Template name
     */
    abstract public function getTemplateName();

    public function getEnvironment()
    {
        return $this->env;
    }

    /**
     * @param array $context
     * @return \Ignus\View\TemplateInterface|boolean
     */
    public function getParent(array $context)
    {
        $parent = $this->doGetParent($context);
        if (false === $parent) {
            return false;
        }
        elseif ($parent instanceof Template) {
            /** @var \Ignus\View\Template $parent */
            $name = $parent->getTemplateName();
            $this->parents[$name] = $parent;
            $parent = $name;
        }
        elseif (!isset($this->parents[$parent])) {
            $this->parents[$parent] = $this->env->loadTemplate($parent);
        }

        return $this->parents[$parent];
    }

    /**
     * @abstract
     * @param array $context
     * @return \Ignus\View\Template
     */
    abstract protected function doGetParent(array $context);

    public function displayParentBlock($name, array $context, array $blocks = array())
    {
        if (isset($this->traits[$name])) {
            $this->traits[$name][0]->displayBlock($name, $context, $blocks);
        }
        elseif (false !== $parent = $this->getParent($context)) {
            $parent->displayBlock($name, $context, $blocks);
        }

        throw new \Runtime(sprintf('The template has no parent and no traits defining the "%s" block', $name), -1, $this->getTemplateName());
    }

    public function displayBlock($name, array $context, array $blocks = array())
    {
        if (isset($blocks[$name])) {
            $b = $blocks;
            unset($b[$name]);
            call_user_func($blocks[$name], $context, $b);
        } elseif (isset($this->blocks[$name])) {
            call_user_func($this->blocks[$name], $context, $blocks);
        } elseif (false !== $parent = $this->getParent($context)) {
            $parent->displayBlock($name, $context, array_merge($this->blocks, $blocks));
        }
    }

    public function renderParentBlock($name, array $context, array $blocks = array())
    {
        ob_start();
        $this->displayParentBlock($name, $context, $blocks);

        return ob_get_clean();
    }

    public function renderBlock($name, array $context, array $blocks = array())
    {
        ob_start();
        $this->displayBlock($name, $context, $blocks);

        return ob_get_clean();
    }

    public function hasBlock($name)
    {
        return isset($this->blocks[$name]);
    }

    public function getBlockNames()
    {
        return array_keys($this->blocks);
    }

    public function getBlocks()
    {
        return $this->blocks;
    }

    public function display(array $context, array $blocks = array())
    {
        try {
            $this->doDisplay($context, $blocks);
        } catch (Error $e) {
            throw $e;
        } catch (\Exception $e) {
            throw new Runtime(sprintf('An exception has been thrown during the rendering of a template ("%s").', $e->getMessage()), -1, null, $e);
        }
    }

    public function render(array $context)
    {
        $level = ob_get_level();
        ob_start();
        try {
            $this->display($context);
        }
        catch (\Exception $e) {
            while (ob_get_level() > $level) {
                ob_end_clean();
            }

            throw $e;
        }

        return ob_get_clean();
    }

    abstract protected function doDisplay(array $context, array $blocks = array());

    protected function getContext($context, $item)
    {
        if (!array_key_exists($item, $context)) {
            if (!$this->env->isDebug())
                return null;

            throw new Runtime(sprintf('Variable "%s" does not exist', $item));
        }

        return $context[$item];
    }

    protected function getAttribute($object, $item, array $arguments = array(), $type = TemplateInterface::ANY_CALL, $noStrictCheck = false)
    {
        // array
        if (TemplateInterface::METHOD_CALL !== $type) {
            if ((is_array($object) || is_object($object) && $object instanceof \ArrayAccess) && isset($object[$item])) {
                return $object[$item];
            }

            if (TemplateInterface::ARRAY_CALL === $type) {
                if (!$this->env->isDebug() || $noStrictCheck) {
                    return null;
                }

                if (is_object($object)) {
                    throw new Runtime(sprintf('Key "%s" in object (with ArrayAccess) of type "%s" does not exist', $item, get_class($object)));
                // array
                } else {
                    throw new Runtime(sprintf('Key "%s" for array with keys "%s" does not exist', $item, implode(', ', array_keys($object))));
                }
            }
        }

        if (!is_object($object)) {
            if (!$this->env->isDebug() || $noStrictCheck) {
                return null;
            }
            throw new Runtime(sprintf('Item "%s" for "%s" does not exist', $item, $object));
        }

        // get some information about the object
        $class = get_class($object);
        if (!isset(self::$cache[$class])) {
            $r = new \ReflectionClass($class);
            self::$cache[$class] = array('methods' => array(), 'properties' => array());
            foreach ($r->getMethods(\ReflectionMethod::IS_PUBLIC) as $method) {
                /** @var \ReflectionMethod $method */
                self::$cache[$class]['methods'][strtolower($method->getName())] = true;
            }

            foreach ($r->getProperties(\ReflectionProperty::IS_PUBLIC) as $property) {
                self::$cache[$class]['properties'][$property->getName()] = true;
            }
        }

        // object property
        if (TemplateInterface::METHOD_CALL !== $type) {
            if (isset(self::$cache[$class]['properties'][$item]) || isset($object->$item)) {
                if ($this->env->hasExtension('sandbox')) {
                    $this->env->getExtension('sandbox')->checkPropertyAllowed($object, $item);
                }

                return $object->$item;
            }
        }

        $lcItem = strtolower($item);
        if (isset(self::$cache[$class]['methods'][$lcItem])) {
            $method = $item;
        } elseif (isset(self::$cache[$class]['methods']['get'.$lcItem])) {
            $method = 'get'.$item;
        } elseif (isset(self::$cache[$class]['methods']['is'.$lcItem])) {
            $method = 'is'.$item;
        } elseif (isset(self::$cache[$class]['methods']['__call'])) {
            $method = $item;
        } else {
            if (!$this->env->isDebug() || $noStrictCheck) {
                return null;
            }

            throw new Runtime(sprintf('Method "%s" for object "%s" does not exist', $item, get_class($object)));
        }

        if ($this->env->hasExtension('sandbox')) {
            $this->env->getExtension('sandbox')->checkMethodAllowed($object, $method);
        }

        $ret = call_user_func_array(array($object, $method), $arguments);

        if ($object instanceof TemplateInterface) {
            return new Markup($ret);
        }

        return $ret;
    }
}
